const AdminService = require('../services/admin.service');
const { successResponse, errorResponse } = require('../utils/response');
const jwt = require('jsonwebtoken');
const { AppError } = require('../utils/error');
const db = require('../models');
const bcrypt = require('bcryptjs');

class AdminController {
    /**
     * 创建管理员
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     */
    async createAdmin(req, res) {
        try {
            const { roleId, ...adminData } = req.body;
            const admin = await AdminService.createAdmin(adminData, roleId);
            successResponse(res, '创建成功', admin);
        } catch (error) {
            errorResponse(res, error.message);
        }
    }

    /**
     * 获取管理员详情
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     */
    async getAdminById(req, res) {
        try {
            const { id } = req.params;
            const admin = await AdminService.getAdminById(id);
            if (!admin) {
                return errorResponse(res, '管理员不存在', 404);
            }
            successResponse(res, '获取成功', admin);
        } catch (error) {
            errorResponse(res, error.message);
        }
    }

    /**
     * 更新管理员信息
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     */
    async updateAdmin(req, res) {
        try {
            const { id } = req.params;
            const admin = await AdminService.updateAdmin(id, req.body);
            successResponse(res, '更新成功', admin);
        } catch (error) {
            errorResponse(res, error.message);
        }
    }

    /**
     * 删除管理员
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     */
    async deleteAdmin(req, res) {
        try {
            const { id } = req.params;
            const result = await AdminService.deleteAdmin(id);
            if (!result) {
                return errorResponse(res, '管理员不存在', 404);
            }
            successResponse(res, '删除成功');
        } catch (error) {
            errorResponse(res, error.message);
        }
    }

    /**
     * 管理员登录
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @param {Function} next - 下一个中间件
     */
    async login(req, res, next) {
        try {
            const { username, password } = req.body;

            if (!username || !password) {
                throw new AppError(400, '用户名和密码不能为空');
            }

            // 查询管理员信息，包括加密盐
            const admin = await db.Admin.findOne({
                where: { username },
                attributes: ['id', 'username', 'password', 'salt', 'role_id', 'status']
            });

            if (!admin) {
                throw new AppError(401, '用户名或密码错误');
            }

            // 使用存储的salt值进行密码验证
            const hashedPassword = await bcrypt.hash(password, admin.salt);
            if (hashedPassword !== admin.password) {
                throw new AppError(401, '用户名或密码错误');
            }

            if (admin.status !== 1) {
                throw new AppError(403, '账号已被禁用');
            }

            // 更新最后登录时间
            await admin.update({
                last_login_time: new Date()
            });

            // 生成token
            const token = jwt.sign(
                {
                    id: admin.id,
                    username: admin.username,
                    role: admin.role_id
                },
                process.env.JWT_SECRET,
                { expiresIn: process.env.JWT_EXPIRES_IN || '24h' }
            );

            // 返回用户信息和token
            res.json({
                status: 'success',
                data: {
                    token,
                    admin: {
                        id: admin.id,
                        username: admin.username,
                        role_id: admin.role_id
                    }
                }
            });
        } catch (error) {
            next(error);
        }
    }

    /**
     * 获取管理员列表
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     */
    async getAdminList(req, res) {
        try {
            const { page = 1, pageSize = 10, ...query } = req.query;
            const result = await AdminService.getAdminList(query, parseInt(page), parseInt(pageSize));
            successResponse(res, '获取成功', result);
        } catch (error) {
            errorResponse(res, error.message);
        }
    }

    /**
     * 获取管理员信息
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @param {Function} next - 下一个中间件
     */
    async getProfile(req, res, next) {
        try {
            const admin = await db.Admin.findByPk(req.user.id, {
                attributes: { exclude: ['password'] }
            });

            if (!admin) {
                throw new AppError(404, '管理员不存在');
            }

            res.json({
                status: 'success',
                data: {
                    id: admin.id,
                    username: admin.username,
                    real_name: admin.real_name,
                    role_id: admin.role_id
                }
            });
        } catch (error) {
            next(error);
        }
    }

    /**
     * 更新管理员信息
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @param {Function} next - 下一个中间件
     */
    async updateProfile(req, res, next) {
        try {
            const { name, email, phone } = req.body;
            await db.Admin.update(
                { name, email, phone },
                { where: { id: req.user.id } }
            );
            res.json({ success: true, message: '个人信息更新成功' });
        } catch (error) {
            next(error);
        }
    }

    /**
     * 修改密码
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @param {Function} next - 下一个中间件
     */
    async changePassword(req, res, next) {
        try {
            const { oldPassword, newPassword } = req.body;

            // 查询管理员信息，包括加密盐
            const admin = await db.Admin.findOne({
                where: { id: req.user.id },
                attributes: ['id', 'password', 'salt']
            });

            if (!admin) {
                throw new AppError(404, '管理员不存在');
            }

            // 使用存储的salt值验证原密码
            const hashedOldPassword = await bcrypt.hash(oldPassword, admin.salt);
            if (hashedOldPassword !== admin.password) {
                throw new AppError(400, '原密码错误');
            }

            // 生成新的salt值
            const newSalt = await bcrypt.genSalt(10);
            const hashedNewPassword = await bcrypt.hash(newPassword, newSalt);

            // 更新密码和salt
            await admin.update({
                password: hashedNewPassword,
                salt: newSalt
            });

            res.json({ success: true, message: '密码修改成功' });
        } catch (error) {
            next(error);
        }
    }

    /**
     * 创建超级管理员
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @param {Function} next - 下一个中间件
     */
    async createSuperAdmin(req, res, next) {
        try {
            const { username, password, real_name } = req.body;

            if (!username || !password) {
                throw new AppError(400, '用户名和密码不能为空');
            }

            // 检查是否已存在超级管理员
            const existingSuperAdmin = await db.Admin.findOne({
                where: { role_id: 1 }, // role_id 1 是超级管理员角色
                attributes: ['id', 'username', 'role_id'] // 只查询必要的字段
            });

            if (existingSuperAdmin) {
                throw new AppError(400, '超级管理员已存在，无法重复创建');
            }

            // 检查用户名是否已存在
            const existingAdmin = await db.Admin.findOne({
                where: { username },
                attributes: ['id', 'username'] // 只查询必要的字段
            });

            if (existingAdmin) {
                throw new AppError(400, '用户名已存在');
            }

            // 生成密码哈希和盐值
            const salt = await bcrypt.genSalt(10);
            const hashedPassword = await bcrypt.hash(password, salt);

            // 创建超级管理员
            const superAdmin = await db.Admin.create({
                username,
                password: hashedPassword,
                salt: salt, // 确保设置 salt 值
                real_name: real_name || '超级管理员',
                role_id: 1, // 超级管理员角色ID
                status: 1
            });

            // 返回创建结果
            res.json({
                status: 'success',
                message: '超级管理员创建成功',
                data: {
                    id: superAdmin.id,
                    username: superAdmin.username,
                    real_name: superAdmin.real_name,
                    role_id: superAdmin.role_id
                }
            });
        } catch (error) {
            next(error);
        }
    }
}

module.exports = new AdminController();